﻿using cszmcaux;
using Microsoft.VisualBasic.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.Metadata;
using System.Text;
using System.Threading.Tasks;

namespace Zhy.SingleZMotion
{
    /// <summary>
    /// 正运动控制操作帮助类
    /// </summary>
    public class Zmotion
    {
        #region 变量
        /// <summary>
        /// IP地址
        /// </summary>
        private string IPAddress = string.Empty;
        /// <summary>
        /// 句柄
        /// </summary>
        private IntPtr Handle;
        /// <summary>
        /// 初始化成功失败标识
        /// 连接成功失败标识
        /// </summary>
        public bool InitedOK = false;
        /// <summary>
        /// 轴0脉冲当量
        /// </summary>
        public int unit0 = 1;
        /// <summary>
        /// 轴1脉冲当量
        /// </summary>
        public int unit1 = 1;
        /// <summary>
        /// 轴2脉冲当量
        /// </summary>
        public int unit2 = 1;
        #endregion

        /// <summary>
        /// 正运动控制操作帮助类
        /// </summary>
        /// <param name="IPAddress">IP地址</param>
        public Zmotion(string IPAddress = "192.168.0.11")
        {
            this.IPAddress = IPAddress;
        }

        /// <summary>
        /// 搜索IP地址集合
        /// </summary>
        /// <returns></returns>
        public List<string> GetEhList()
        {
            StringBuilder ipAddressList = new StringBuilder();
            uint addbufferlength = 1000;
            int error = Zmcaux.ZAux_SearchEthlist(ipAddressList, addbufferlength,10); // 快速搜索IP地址
            if (error == 0)  // 搜索成功
            {
                string result=ipAddressList.ToString().Trim();
                if (result.Contains(' '))
                {
                    return result.Split(' ').ToList(); // 获取ip地址集合
                }
                else 
                {
                    return new List<string> { result };
                }
            }
            return new List<string>();
        }

        /// <summary>
        /// 初始化运动控制卡
        /// </summary>
        /// <returns></returns>
        public OperationResult InitCard()
        {
            // 调用连接控制器的方法
            int result = Zmcaux.ZAux_OpenEth(IPAddress, out IntPtr handle);
            if (result == 0 && Handle != IntPtr.Zero)
            {
                InitedOK = true;
                return OperationResult.CreateSuccessResult(); // 返回连接成功
            }
            else
            {
                InitedOK = false;
                return OperationResult.CreateFailResult(); // 返回连接失败
            }
        }

        /// <summary>
        /// 关闭运动控制卡
        /// </summary>
        /// <returns></returns>
        public OperationResult CloseCard()
        {
            // 关闭控制器连接
            int res = Zmcaux.ZAux_Close(Handle);
            if (res == 0) // 关闭失败 
            {
                Handle = IntPtr.Zero;
                InitedOK = false;
                return OperationResult.CreateSuccessResult();
            }
            return OperationResult.CreateFailResult(); // 关闭失败
        }

        /// <summary>
        /// 连续移动
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <param name="vel">速度/运行速度</param>
        /// <param name="dir">方向 (左、右、正、负)</param>
        /// <param name="velMin">最小速度/起始速度</param>
        /// <param name="acc">加速度</param>
        /// <param name="dec">减速度</param>
        /// <param name="sramp">S曲线时间</param>
        /// <returns>操作结果</returns>
        public OperationResult VMove(short axis, float vel, bool dir, float velMin, float acc, float dec, float sramp)
        {
            // 判断是否满足运动条件
            var result = CommonMotionValidate(axis);
            if (!result.IsSuccess)
            {
                return result; // 轴正在运动
            }
            // 创建错误码
            int error = 0;
            try
            {
                error = Zmcaux.ZAux_Direct_SetAtype(Handle, axis, 1); // 设置轴类型 1 是脉冲步进或伺服
                ErrorHandle("ZAux_Direct_SetAtype", error); // 错误处理
                switch (axis)
                {
                    case 0: // 轴0
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit0); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    case 1: //轴1
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit1); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    case 2: //轴2
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit2); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    default: break;
                }
                // 设置运动曲线 、，，，s曲线
                error = Zmcaux.ZAux_Direct_SetLspeed(Handle, axis, velMin); // 起始速度
                ErrorHandle("ZAux_Direct_SetLspeed", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetSpeed(Handle, axis, vel); // 运行速度
                ErrorHandle("ZAux_Direct_SetSpeed", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetAccel(Handle, axis, acc); // 加速度
                ErrorHandle("ZAux_Direct_SetAccel", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetDecel(Handle, axis, dec); // 减速度
                ErrorHandle("ZAux_Direct_SetDecel", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetSramp(Handle, axis, sramp); // s曲线-是为了运行更平滑一些
                ErrorHandle("ZAux_Direct_SetSramp", error); // 错误处理
                error = Zmcaux.ZAux_Direct_Single_Vmove(Handle, axis, dir ? 1 : -1); // 启动连续运动
                ErrorHandle("ZAux_Direct_Single_Vmove", error); // 错误处理
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.ErrorMsg = ex.Message;
                return result;
            }
            return OperationResult.CreateSuccessResult();
        }

        /// <summary>
        /// 相对运动
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <param name="vel">运行速度</param>
        /// <param name="distance">移动距离</param>
        /// <param name="velMin">最小速度</param>
        /// <param name="acc">加速度</param>
        /// <param name="dec">减速度</param>
        /// <param name="sramp">S曲线</param>
        /// <returns></returns>
        public OperationResult MoveRelative(short axis, float vel, float distance, float velMin, float acc, float dec, float sramp)
        {
            // 判断是否满足运动条件
            var result = CommonMotionValidate(axis);
            if (!result.IsSuccess)
            {
                return result; // 轴正在运动
            }
            // 创建错误码
            int error = 0;
            try
            {
                error = Zmcaux.ZAux_Direct_SetAtype(Handle, axis, 1); // 设置轴类型 1 是脉冲步进或伺服
                ErrorHandle("ZAux_Direct_SetAtype", error); // 错误处理
                switch (axis)
                {
                    case 0: // 轴0
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit0); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    case 1: //轴1
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit1); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    case 2: //轴2
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit2); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    default: break;
                }
                // 设置运动曲线 、，，，s曲线
                error = Zmcaux.ZAux_Direct_SetLspeed(Handle, axis, velMin); // 起始速度
                ErrorHandle("ZAux_Direct_SetLspeed", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetSpeed(Handle, axis, vel); // 运行速度
                ErrorHandle("ZAux_Direct_SetSpeed", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetAccel(Handle, axis, acc); // 加速度
                ErrorHandle("ZAux_Direct_SetAccel", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetDecel(Handle, axis, dec); // 减速度
                ErrorHandle("ZAux_Direct_SetDecel", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetSramp(Handle, axis, sramp); // s曲线-是为了运行更平滑一些
                ErrorHandle("ZAux_Direct_SetSramp", error); // 错误处理
                error = Zmcaux.ZAux_Direct_Single_Move(Handle, axis, distance); // 相对于当前位置增加移动距离
                ErrorHandle("ZAux_Direct_Single_Move", error); // 错误处理
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.ErrorMsg = ex.Message;
                return result;
            }
            return OperationResult.CreateSuccessResult();
        }

        /// <summary>
        /// 绝对运动
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <param name="vel">运行速度</param>
        /// <param name="pos">位置</param>
        /// <param name="velMin">最小速度</param>
        /// <param name="acc">加速度</param>
        /// <param name="dec">减速度</param>
        /// <param name="sramp">S曲线</param>
        /// <returns></returns>
        public OperationResult MoveAbs(short axis, float vel, float pos, float velMin, float acc, float dec, float sramp)
        {
            // 判断是否满足运动条件
            var result = CommonMotionValidate(axis);
            if (!result.IsSuccess)
            {
                return result; // 轴正在运动
            }
            // 创建错误码
            int error = 0;
            try
            {
                error = Zmcaux.ZAux_Direct_SetAtype(Handle, axis, 1); // 设置轴类型 1 是脉冲步进或伺服
                ErrorHandle("ZAux_Direct_SetAtype", error); // 错误处理
                switch (axis)
                {
                    case 0: // 轴0
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit0); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    case 1: //轴1
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit1); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    case 2: //轴2
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit2); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    default: break;
                }
                // 设置运动曲线 、，，，s曲线
                error = Zmcaux.ZAux_Direct_SetLspeed(Handle, axis, velMin); // 起始速度
                ErrorHandle("ZAux_Direct_SetLspeed", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetSpeed(Handle, axis, vel); // 运行速度
                ErrorHandle("ZAux_Direct_SetSpeed", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetAccel(Handle, axis, acc); // 加速度
                ErrorHandle("ZAux_Direct_SetAccel", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetDecel(Handle, axis, dec); // 减速度
                ErrorHandle("ZAux_Direct_SetDecel", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetSramp(Handle, axis, sramp); // s曲线-是为了运行更平滑一些
                ErrorHandle("ZAux_Direct_SetSramp", error); // 错误处理
                error = Zmcaux.ZAux_Direct_Single_MoveAbs(Handle, axis, pos); // 以中心点为准，往左是正、往右是负。
                ErrorHandle("ZAux_Direct_Single_MoveAbs", error); // 错误处理
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.ErrorMsg = ex.Message;
                return result;
            }
            return OperationResult.CreateSuccessResult();
        }

        /// <summary>
        /// 通用回原点操作
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <param name="vel">运行速度</param>
        /// <param name="crep">回原点速度</param>
        /// <param name="homeio">回原点信号</param>
        /// <param name="distance">原点限位位置</param>
        /// <param name="velMin">最小速度</param>
        /// <param name="acc">加速度</param>
        /// <param name="dec">减速度</param>
        /// <param name="sramp">S曲线</param>
        /// <param name="homemode">回原点模式</param>
        /// <returns>操作结果</returns>
        public OperationResult ZeroAxis(short axis, float vel, float creep, int homeio, float distance, float velMin, float acc, float dec, float sramp, int homemode = 4)
        {
            // 判断是否满足运动条件
            var result = CommonMotionValidate(axis);
            if (!result.IsSuccess)
            {
                return result; // 轴正在运动
            }

            // 先网原点方向一直走，直到到达限位
            result = MoveRelative(axis, vel, -500, velMin, acc, dec, sramp);
            if (!result.IsSuccess) return result; // 错误返回

            // 等待停止
            result = WaitStop(axis);
            if (!result.IsSuccess) return result; // 错误返回

            // 执行位置清零
            result = ZeroPos(axis);
            if (!result.IsSuccess) return result; // 错误返回

            // 往返向走一段距离，超过原点和限位的距离
            result = MoveRelative(axis, vel, distance, velMin, acc, dec, sramp);
            if (!result.IsSuccess) return result; // 错误返回

            // 等待停止
            result = WaitStop(axis);
            if (!result.IsSuccess) return result; // 错误返回

            // 直接回零
            result = DirectZeroAxis(axis, vel, creep, homeio, velMin, acc, dec, homemode);
            if (!result.IsSuccess) return result; // 错误返回

            // 等待回零停止
            result = WaitHomeStop(axis);
            if (!result.IsSuccess) return result; // 错误返回

            return OperationResult.CreateSuccessResult(); // 回原点成功
        }

        /// <summary>
        /// 直接回原点
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <param name="vel">运行速度</param>
        /// <param name="crep">回原点速度</param>
        /// <param name="homeio">回原点信号</param>
        /// <param name="velMin">最小速度</param>
        /// <param name="acc">加速度</param>
        /// <param name="dec">减速度</param>
        /// <param name="homemode">回原点模式</param>
        /// <returns>操作</returns>
        public OperationResult DirectZeroAxis(short axis, float vel, float creep, int homeio, float velMin, float acc, float dec, int homemode = 4)
        {
            // 判断是否满足运动条件
            var result = CommonMotionValidate(axis);
            if (!result.IsSuccess)
            {
                return result; // 轴正在运动
            }
            // 创建错误码
            int error = 0;
            try
            {
                error = Zmcaux.ZAux_Direct_SetAtype(Handle, axis, 1); // 设置轴类型 1 是脉冲步进或伺服
                ErrorHandle("ZAux_Direct_SetAtype", error); // 错误处理
                switch (axis)
                {
                    case 0: // 轴0
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit0); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    case 1: //轴1
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit1); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    case 2: //轴2
                        error = Zmcaux.ZAux_Direct_SetUnits(Handle, axis, unit2); // 脉冲当量
                        ErrorHandle("ZAux_Direct_SetUnits", error); // 错误处理
                        break;
                    default: break;
                }
                // 设置运动曲线 、，，，s曲线
                error = Zmcaux.ZAux_Direct_SetLspeed(Handle, axis, velMin); // 起始速度
                ErrorHandle("ZAux_Direct_SetLspeed", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetSpeed(Handle, axis, vel); // 运行速度
                ErrorHandle("ZAux_Direct_SetSpeed", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetAccel(Handle, axis, acc); // 加速度
                ErrorHandle("ZAux_Direct_SetAccel", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetDecel(Handle, axis, dec); // 减速度
                ErrorHandle("ZAux_Direct_SetDecel", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetCreep(Handle, axis, creep); // 设置爬行速度-让回原点平滑一些
                ErrorHandle("ZAux_Direct_SetCreep", error); // 错误处理
                error = Zmcaux.ZAux_Direct_SetDatumIn(Handle, axis, homeio); // 设置原点信号
                ErrorHandle("ZAux_Direct_SetDatumIn", error); // 错误处理
                error = Zmcaux.ZAux_Direct_Single_Datum(Handle, axis, homemode); // 执行回原点
                ErrorHandle("ZAux_Direct_Single_Datum", error); // 错误处理
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.ErrorMsg = ex.Message;
                return result;
            }
            return OperationResult.CreateSuccessResult();
        }

        /// <summary>
        /// 轴回原点
        /// 已在伺服电机的轴回原点测试通过
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <param name="DatumOut">回原点输出信号</param>
        /// <param name="DatumIn">原点已到位信号</param>
        /// <param name="ArrivalIn">已到达指定点信号</param>
        public void MoveToOrigin(short axis, int DatumOut, int DatumIn, int ArrivalIn)
        {
            if (axis < 0) return;

            Zmcaux.ZAux_Direct_SetOp(Handle, DatumOut, 1);  // 控制轴回原点开始移动

            int endTime = Environment.TickCount + 60 * 1000;
            uint arrivalIn = 0;
            uint datumIn = 0;
            do
            {
                Thread.Sleep(100);
                Zmcaux.ZAux_Direct_GetIn(Handle, ArrivalIn, ref arrivalIn);  // 获取到达指定位置信号
                Zmcaux.ZAux_Direct_GetIn(Handle, DatumIn, ref datumIn);  // 获取到达原点位置信号
            } while ((arrivalIn != 1 || datumIn != 1) && Environment.TickCount < endTime);

            Zmcaux.ZAux_Direct_SetOp(Handle, DatumOut, 0);  // 设置以回到原点停止移动
            Zmcaux.ZAux_Direct_SetDpos(Handle, axis, 0);  // 位置清零-清零后绝对位置才能计算
        }

        /// <summary>
        /// 等待停止
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <returns></returns>
        public OperationResult WaitStop(short axis)
        {
            // 判断是否满足运动条件
            var result = CommonMotionValidate(axis);
            if (!result.IsSuccess)
            {
                return result; // 轴正在运动
            }
            // 创建错误码
            int error = 0;
            // 运行状态
            int runstate = 0;

            do
            {
                error = Zmcaux.ZAux_Direct_GetIfIdle(Handle, axis, ref runstate); // 获取运行状态
                ErrorHandle("ZAux_Direct_GetIfIdle", error); // 错误处理

            } while (runstate == 0); // 等于1就是运行停止了

            return OperationResult.CreateSuccessResult();
        }

        /// <summary>
        /// 等待回零停止
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <returns></returns>
        public OperationResult WaitHomeStop(short axis)
        {
            // 判断是否满足运动条件
            var result = CommonMotionValidate(axis);
            if (!result.IsSuccess)
            {
                return result; // 轴正在运动
            }
            // 创建错误码
            int error = 0;
            // 运行状态
            uint hometate = 0;

            do
            {
                error = Zmcaux.ZAux_Direct_GetHomeStatus(Handle, axis, ref hometate); // 获取运行状态
                ErrorHandle("ZAux_Direct_GetIfIdle", error); // 错误处理

            } while (hometate == 0); // 等于1就是运行停止了

            return OperationResult.CreateSuccessResult();
        }

        /// <summary>
        /// 获取实时运行速度值
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <returns></returns>
        public float GetVel(short axis)
        {
            // 判断是否满足运动条件
            var result = CommonMotionValidate(axis);
            if (!result.IsSuccess)
            {  // 没有初始化
                return 0.0f; // 返回0
            }
            // 定义速度
            float vel = 0.0f;
            // 定义错误码
            int error = 0;

            try
            {
                error = Zmcaux.ZAux_Direct_GetVpSpeed(Handle, axis, ref vel); // 获取规划运行速度
                ErrorHandle("ZAux_Direct_GetVpSpeed", error); // 错误处理
                return vel;
            }
            catch (Exception ex)
            {   // 获取运行速度失败
                return 0.0f;
            }
        }

        /// <summary>
        /// 获取实时位置
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <returns></returns>
        public float GetPos(short axis)
        {
            // 判断是否满足运动条件
            var result = CommonMotionValidate(axis);
            if (!result.IsSuccess)
            {  // 没有初始化
                return 0.0f; // 返回0
            }
            // 定义速度
            float vel = 0.0f;
            // 定义错误码
            int error = 0;

            try
            {
                // 下面这两个方法差别不大
                //error = Zmcaux.ZAux_Direct_GetDpos(Handle, axis, ref vel); // 获取获取当前设置位置
                error = Zmcaux.ZAux_Direct_GetMpos(Handle, axis, ref vel); // 获取获取当前反馈位置
                ErrorHandle("ZAux_Direct_GetDpos", error); // 错误处理
                return vel;
            }
            catch (Exception ex)
            {   // 获取运行速度失败
                return 0.0f;
            }
        }

        /// <summary>
        /// 停止轴运动
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <returns>操作结果</returns>
        public OperationResult StopAxis(short axis)
        {
            // 判断是否满足运动条件
            var result = CommonMotionValidate(axis);
            if (!result.IsSuccess)
            {  // 没有初始化
                return result;
            }
            // 定义错误码
            int error = 0;
            try
            {
                // 2 取消当前运动和缓冲运动
                error = Zmcaux.ZAux_Direct_Single_Cancel(Handle, axis, 2); // 停止运动
                ErrorHandle("ZAux_Direct_Single_Cancel", error); // 错误处理
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.ErrorMsg = ex.Message;
                return result;
            }
            return OperationResult.CreateSuccessResult();
        }

        /// <summary>
        /// 所有轴停止运动
        /// </summary>
        /// <returns></returns>
        public OperationResult StopAllAxis()
        {
            // 判断是否满足运动条件
            var result = ConmmonInitedValidate();
            if (!result.IsSuccess)
            {  // 没有初始化
                return result;
            }
            // 定义错误码
            int error = 0;
            try
            {
                // 数组中是轴序号 3 立即停止
                error = Zmcaux.ZAux_Direct_CancelAxisList(Handle, 4, new int[] { 0, 1, 2, 3 }, 3); // 停止全部轴运动
                ErrorHandle("ZAux_Direct_CancelAxisList", error); // 错误处理
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.ErrorMsg = ex.Message;
                return result;
            }
            return OperationResult.CreateSuccessResult();
        }

        /// <summary>
        /// 位置清零
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <returns></returns>
        public OperationResult ZeroPos(short axis)
        {
            // 判断是否满足运动条件
            var result = CommonMotionValidate(axis);
            if (!result.IsSuccess)
            {  // 没有初始化
                return result;
            }
            // 定义错误码
            int error = 0;
            try
            {
                error = Zmcaux.ZAux_Direct_SetMpos(Handle, axis, 0.0f); // 位置清零
                ErrorHandle("ZAux_Direct_SetMpos", error); // 错误处理
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.ErrorMsg = ex.Message;
                return result;
            }
            return OperationResult.CreateSuccessResult();
        }

        /// <summary>
        /// 通用的运动验证
        /// </summary>
        /// <param name="axis">轴号</param>
        /// <returns></returns>
        private OperationResult CommonMotionValidate(short axis)
        {
            OperationResult result = ConmmonInitedValidate(); // 获取是否已经初始化
            // 判断是否已经初始化
            if (result.IsSuccess) return result;
            // 判断是否正在运行
            if (IsMoving(axis))
            {
                result.IsSuccess = false;
                result.ErrorMsg = "轴正在运行";
                return result;
            }
            return OperationResult.CreateSuccessResult();
        }

        /// <summary>
        /// 判断是否已经初始化
        /// </summary>
        /// <returns></returns>
        private OperationResult ConmmonInitedValidate()
        {
            OperationResult result = new OperationResult();
            // 判断是否已经初始化
            if (!InitedOK)
            {
                result.IsSuccess = false;
                result.ErrorMsg = "控制器连接失败";
                return result;
            }
            else
            {
                return OperationResult.CreateSuccessResult(); // 已初始化
            }
        }

        /// <summary>
        /// 错误处理
        /// </summary>
        /// <param name="command">执行命令</param>
        /// <param name="error">错误码</param>
        private void ErrorHandle(string command, int error)
        {
            string result = string.Empty;
            switch (error)
            {
                case 0: break;
                default:
                    result = $"{command}指令执行错误，错误码为{error}";
                    break;
            }
            if (result.Length > 0)
            {
                throw new Exception(result);
            }
        }

        /// <summary>
        /// 判断某个轴知否正在运行
        /// </summary>
        /// <param name="axis"></param>
        /// <returns>true：正在运动</returns>
        public bool IsMoving(short axis)
        {
            OperationResult result = ConmmonInitedValidate();
            // 判断是否已经初始化
            if (result.IsSuccess) return false;
            // 定义运行状态
            int runstate = -1;
            // 定义错误码
            int error = 0;
            try
            {
                // 获取轴状态
                error = Zmcaux.ZAux_Direct_GetIfIdle(Handle, axis, ref runstate);
                ErrorHandle("ZAux_Direct_GetIfIdle", error); // 错误处理
                // 返回轴状态
                return runstate == 0;
            }
            catch (Exception ex)
            {
                return true; // 轴正在运行
            }
        }
    }

    /// <summary>
    /// 操作结果类
    /// </summary>
    public class OperationResult
    {
        /// <summary>
        /// 是否成功
        /// </summary>
        public bool IsSuccess { get; set; }
        /// <summary>
        /// 错误信息
        /// </summary>
        public string ErrorMsg { get; set; }

        /// <summary>
        /// 快速返回成功结果
        /// </summary>
        /// <returns></returns>
        public static OperationResult CreateSuccessResult()
        {
            return new OperationResult
            {
                IsSuccess = true,
                ErrorMsg = "成功"
            };
        }

        /// <summary>
        /// 快速返回失败结果
        /// </summary>
        /// <returns></returns>
        public static OperationResult CreateFailResult()
        {
            return new OperationResult
            {
                IsSuccess = false,
                ErrorMsg = "失败"
            };
        }
    }
}
